home *** CD-ROM | disk | FTP | other *** search
/ Aminet 2 / Aminet AMIGA CDROM (1994)(Walnut Creek)[Feb 1994][W.O. 44790-1].iso / Aminet / misc / amag / sh9302a.lha / Patchen (S.53) / Purge / Purge.c < prev    next >
C/C++ Source or Header  |  1992-11-30  |  5KB  |  171 lines
  1. #include <stdio.h>
  2. #include <string.h>
  3. #include <exec/exec.h>
  4. #include <proto/dos.h>
  5. #include <proto/exec.h>
  6.  
  7. void main(int,char **);
  8. short __regargs purge(char *,char *);
  9. void __regargs scandir(char *,char *);
  10.  
  11. short recur;
  12.  
  13. void main(int argc,char **argv)
  14. {
  15.    static char path[256],node[256],*filep;
  16.    long len;
  17.    if (!argc)
  18.       return;
  19.    if (argc==2 && argv[1][0]=='?')
  20.    {
  21.       FPuts(Output(),"USAGE : purge [-r] <file>\n");
  22.       return;
  23.    }
  24.    if (argc==3 && argv[1][0]=='-' && argv[1][1]=='r')
  25.       recur=1;
  26.    if (filep=FilePart(argv[argc-1]))    /* Pfad und Pattern trennen */
  27.    {
  28.       len=filep-argv[argc-1];
  29.       strncpy(path,argv[argc-1],len);
  30.       strcpy(node,filep);
  31.       scandir(path,node);
  32.    }
  33. }
  34.  
  35. void __regargs scandir(char *path,char *pattern)
  36. {
  37.    static char buffer[516],left[256],right[256];
  38.    char *buffer1,*p;
  39.    struct FileInfoBlock *fib;
  40.    BPTR lock;
  41.    short success=1,patt,purged=0;
  42.    
  43.    /* Zwischenspeicher allokieren */
  44.    
  45.    if (!(buffer1=(char *)AllocVec(256,MEMF_CLEAR|MEMF_PUBLIC)))
  46.    {
  47.       FPuts(Output(),"Nicht genug Speicher\n");
  48.       return;
  49.    }
  50.    if (!(fib=(struct FileInfoBlock*)AllocVec(sizeof(struct FileInfoBlock),MEMF_CLEAR|MEMF_PUBLIC)))
  51.    {
  52.       FPuts(Output(),"Nicht genug Speicher\n");
  53.       FreeVec(buffer1);
  54.       return;
  55.    }
  56.    patt=ParsePattern(pattern,buffer,512);
  57.    if (lock=Lock(path,ACCESS_READ))
  58.    {
  59.       if (Examine(lock,fib))
  60.       {
  61.          while (success)   /* Verzeichnis auf Matches prüfen */    
  62.          {
  63.             success=ExNext(lock,fib);
  64.             
  65.             /* Pattern vorhanden ==> Dateinamen vergleichen */
  66.             
  67.             if (patt && fib->fib_DirEntryType<=0 && MatchPattern(buffer,fib->fib_FileName))
  68.             {
  69.                if (p=stpchr(fib->fib_FileName,'.'))
  70.                {
  71.                   /* Wenn Punkt im Dateinamen, dann Namenstamm abtrennen
  72.                      und versuchen diese Gruppe zu löschen */
  73.                   memset(left,0,sizeof(left));
  74.                   strncpy(left,fib->fib_FileName,p-(fib->fib_FileName));
  75.                   strcpy(right,p+4);
  76.                   strcat(left,right);
  77.                   if (purge(path,left))
  78.                   {
  79.                      UnLock(lock);  
  80.                      /* Dateien gelöscht, Dir. muß neu "gelockt" werden */
  81.                      if (lock=Lock(path,ACCESS_READ))
  82.                      {
  83.                         Examine(lock,fib);
  84.                         success=ExNext(lock,fib); /* ExNext für Volume */
  85.                      }
  86.                   }
  87.                }
  88.             }
  89.             /* Namen ohne Pattern angegeben und noch kein purge auf dieses
  90.                Verzeichnis */
  91.             else if (fib->fib_DirEntryType<=0 && !patt && !purged)
  92.             {
  93.                if (purge(path,pattern))
  94.                {
  95.                   purged=1;
  96.                   UnLock(lock);  /* Dateien gelöscht ==> neuer Lock */
  97.                   if (lock=Lock(path,ACCESS_READ))
  98.                   {
  99.                      Examine(lock,fib);   /* ExNext für Volume */
  100.                      success=ExNext(lock,fib);
  101.                   }
  102.                }
  103.             }
  104.             /* Unterverzeichnis und "-r"-Flag angegeben */
  105.             if (fib->fib_DirEntryType>0 && recur)
  106.             {
  107.                strcpy(buffer1,path);             /* Pfad retten */
  108.                strcat(path,fib->fib_FileName);   /* neuer Pfad  */
  109.                strcat(path,"/");                 /* Slash dazu  */
  110.                UnLock(lock);                     /* altes Lock freigeben */
  111.                scandir(path,pattern);            /* und Rekursion */
  112.                strcpy(path,buffer1);             /* alten Pfad zurück */
  113.                if (!(lock=Lock(path,ACCESS_READ))) /* und "relock" */
  114.                   return;
  115.             }
  116.          }
  117.       }
  118.       UnLock(lock);
  119.    }
  120.    FreeVec(buffer1);  /* Speicher freigeben */
  121.    FreeVec(fib);
  122. }
  123.  
  124. short __regargs purge(char *path,char *name)
  125. {
  126.    BPTR fh;
  127.    short x,max,purged=0;
  128.    static char substring[256],string[256],help[256],*p;
  129.    strcpy(string,path);
  130.    strcat(string,name);
  131.    strcpy(help,string);
  132.    strcat(help,".vers");
  133.    if (p=stpchr(string,'.'))
  134.    {
  135.       strcpy(substring,p);
  136.       if (fh=Open(help,MODE_OLDFILE))  /* Versionsdatei öffnen */
  137.       {
  138.          FRead(fh,&max,sizeof(max),1); /* höchste Versionsnummer */
  139.          if (max>1)
  140.          {
  141.             for (x=max-1;x>0;x--)
  142.             {
  143.                purged=1;
  144.                sprintf(p,".%03d",x);    /* Dateinamen mit Versionsnr. erstellen */
  145.                strcat(string,substring);
  146.                string[strlen(string)]=0;
  147.                DeleteFile(string);      /* Version "x" der Datei löschen */
  148.                strcpy(help,string);
  149.                strcat(help," - purged\n");
  150.                FPuts(Output(),help);
  151.             }
  152.             sprintf(p,".%03d",max);
  153.             strcat(string,substring);
  154.             strcpy(help,string);
  155.             *p='.';
  156.             *(p+1)='0';
  157.             *(p+2)='0';
  158.             *(p+3)='1';
  159.             Rename(help,string); /* und höchste Version umbenennen */
  160.             max=1;               /* Versionsdatei neu schreiben ("1") */
  161.             Seek(fh,0,OFFSET_BEGINNING);
  162.             FWrite(fh,&max,sizeof(max),1);
  163.          }
  164.          Close(fh);
  165.       }
  166.    }
  167.    return(purged);
  168. }
  169.  
  170.          
  171.